/*
<application>JAVASCRIPT ASSERTION UNIT</application>
<version>1.1</version>
<author>D. Fournier</author>
<e-mail>zenon48@users.sourceforge.net</e-mail>
<copyright>2002 ID EST</copyright>
<license>GPL</license>
<filename>coretest.js</filename>
<documentation></documentation>
*/
var
/*boolean*/DO_ASSERT = true, DONT_ASSERT = false;	///globaly enable the assertions chacking
var
/*undefined*/IS_UNDEFINED;
var
/*null*/IS_NULL = null;
var
/*null*/IS_TRUE = true;
var
/*null*/IS_FALSE = false;
var
/*string*/IS_EMPTY_STRING = '';
var
/*string*/IS_STRING = '<\'jsAssertUnit\'>: "JAVASCRIPT" ASSERTION UNIT';	//a tricky string to check quote and tag conversion
var
/*int*/IS_ZERO_NUMBER = 0;
var
/*int*/IS_NUMBER = 9876;
var
/*int*/IS_HEX_NUMBER = 0x01EF;
var
/*any[]*/IS_EMPTY_ARRAY = [];
var
/*any[]*/IS_ARRAY = [IS_STRING, IS_NUMBER];
var
/*any[]*/IS_EMPTY_OBJECT = {};
var
/*any[]*/IS_OBJECT = {proString:IS_STRING, proInt:IS_NUMBER};
var
/*function*/IS_FUNCTION = function(){}


/*f)void*/function
TEST_core(){
TEST_isNull();
TEST_isNotNull();
TEST_isUndefined();
TEST_isNotUndefined();
TEST_isTrue();
TEST_isFalse();
TEST_isNumber();
TEST_isNotNumber();
TEST_isEqualToString();
TEST_isNotEqualToString();
}	//---TEST_core

/*f)void*/function
TEST_isNull(){
var
/*string*/atCall = 'TEST_isNull: ';

Assert.warn('TEST_isNull: TESTS with IS_NULL');
Assert.isNull(IS_NULL, DO_ASSERT, atCall + 'IS_NULL is null');

Assert.warn('TEST_isNull: TESTS with IS_UNDEFINED');
Assert.isNull(IS_UNDEFINED, DO_ASSERT, atCall + 'IS_UNDEFINED is undefined');

Assert.warn('TEST_isNull: TESTS with IS_TRUE');
Assert.isNull(IS_TRUE, DO_ASSERT, atCall + 'IS_TRUE is true');

Assert.warn('TEST_isNull: TESTS with IS_FALSE');
Assert.isNull(IS_FALSE, DO_ASSERT, atCall + 'IS_FALSE is false');

Assert.warn('TEST_isNull: TESTS with IS_EMPTY_STRING');
Assert.isNull(IS_EMPTY_STRING, DO_ASSERT, atCall + 'IS_EMPTY_STRING is ""');

Assert.warn('TEST_isNull: TESTS with IS_STRING');
Assert.isNull(IS_STRING, DO_ASSERT, atCall + 'IS_STRING is ' + IS_STRING);

Assert.warn('TEST_isNull: TESTS with IS_ZERO_NUMBER');
Assert.isNull(IS_ZERO_NUMBER, DO_ASSERT, atCall + 'IS_ZERO_NUMBER is ' + IS_ZERO_NUMBER);

Assert.warn('TEST_isNull: TESTS with IS_NUMBER');
Assert.isNull(IS_NUMBER, DO_ASSERT, atCall + 'IS_NUMBER is ' + IS_NUMBER);

Assert.warn('TEST_isNull: TESTS with IS_HEX_NUMBER');
Assert.isNull(IS_HEX_NUMBER, DO_ASSERT, atCall + 'IS_HEX_NUMBER is ' + IS_HEX_NUMBER);

Assert.warn('TEST_isNull: TESTS with IS_EMPTY_ARRAY');
Assert.isNull(IS_EMPTY_ARRAY, DO_ASSERT, atCall + 'IS_EMPTY_ARRAY is []');

Assert.warn('TEST_isNull: TESTS with IS_ARRAY');
Assert.isNull(IS_ARRAY, DO_ASSERT, atCall + 'IS_ARRAY is [<\'jsAssertUnit\'>: "JAVASCRIPT" ASSERTION UNIT, 9876]');

Assert.warn('TEST_isNull: TESTS with IS_EMPTY_OBJECT');
Assert.isNull(IS_EMPTY_OBJECT, DO_ASSERT, atCall + 'IS_EMPTY_OBJECT is {}');

Assert.warn('TEST_isNull: TESTS with IS_OBJECT');
Assert.isNull(IS_OBJECT, DO_ASSERT, atCall + 'IS_OBJECT is {proString:<\'jsAssertUnit\'>: "JAVASCRIPT" ASSERTION UNIT, proInt:9876}');

/*
-------------------------
Assert.warn('TEST_isNull: TESTS with IS_FUNCTION');
Assert.isNull(IS_FUNCTION, DO_ASSERT, atCall + '"IS_FUNCTION" is function(){}');
-------------------------
*/
}	//---TEST_isNull

/*f)void*/function
TEST_isNotNull(){
var
/*string*/atCall = 'TEST_isNotNull: ';

Assert.warn('TEST_isNotNull: TESTS with IS_NULL');
Assert.isNotNull(IS_NULL, DO_ASSERT, atCall + 'IS_NULL is null');

Assert.warn('TEST_isNotNull: TESTS with IS_UNDEFINED');
Assert.isNotNull(IS_UNDEFINED, DO_ASSERT, atCall + 'IS_UNDEFINED is undefined');

Assert.warn('TEST_isNotNull: TESTS with IS_TRUE');
Assert.isNotNull(IS_TRUE, DO_ASSERT, atCall + 'IS_TRUE is true');

Assert.warn('TEST_isNotNull: TESTS with IS_FALSE');
Assert.isNotNull(IS_FALSE, DO_ASSERT, atCall + 'IS_FALSE is false');

Assert.warn('TEST_isNotNull: TESTS with IS_EMPTY_STRING');
Assert.isNotNull(IS_EMPTY_STRING, DO_ASSERT, atCall + 'IS_EMPTY_STRING is ""');

Assert.warn('TEST_isNotNull: TESTS with IS_STRING');
Assert.isNotNull(IS_STRING, DO_ASSERT, atCall + 'IS_STRING is ' + IS_STRING);

Assert.warn('TEST_isNotNull: TESTS with IS_ZERO_NUMBER');
Assert.isNotNull(IS_ZERO_NUMBER, DO_ASSERT, atCall + 'IS_ZERO_NUMBER is ' + IS_ZERO_NUMBER);

Assert.warn('TEST_isNotNull: TESTS with IS_NUMBER');
Assert.isNotNull(IS_NUMBER, DO_ASSERT, atCall + 'IS_NUMBER is ' + IS_NUMBER);

Assert.warn('TEST_isNotNull: TESTS with IS_HEX_NUMBER');
Assert.isNotNull(IS_HEX_NUMBER, DO_ASSERT, atCall + 'IS_HEX_NUMBER is ' + IS_HEX_NUMBER);

Assert.warn('TEST_isNotNull: TESTS with IS_EMPTY_ARRAY');
Assert.isNotNull(IS_EMPTY_ARRAY, DO_ASSERT, atCall + 'IS_EMPTY_ARRAY is []');

Assert.warn('TEST_isNotNull: TESTS with IS_ARRAY');
Assert.isNotNull(IS_ARRAY, DO_ASSERT, atCall + 'IS_ARRAY is [<\'jsAssertUnit\'>: "JAVASCRIPT" ASSERTION UNIT, 9876]');

Assert.warn('TEST_isNotNull: TESTS with IS_EMPTY_OBJECT');
Assert.isNotNull(IS_EMPTY_OBJECT, DO_ASSERT, atCall + 'IS_EMPTY_OBJECT is {}');

Assert.warn('TEST_isNotNull: TESTS with IS_OBJECT');
Assert.isNotNull(IS_OBJECT, DO_ASSERT, atCall + 'IS_OBJECT is {proString:<\'jsAssertUnit\'>: "JAVASCRIPT" ASSERTION UNIT, proInt:9876}');

/*
-------------------------
Assert.warn('TEST_isNotNull: TESTS with IS_FUNCTION');
Assert.isNotNull(IS_FUNCTION, DO_ASSERT, atCall + '"IS_FUNCTION" is function(){}');
-------------------------
*/
}	//---TEST_isNotNull

/*f)void*/function
TEST_isUndefined(){
var
/*string*/atCall = 'TEST_isUndefined: ';

Assert.warn('TEST_isUndefined: TESTS with IS_NULL');
Assert.isUndefined(IS_NULL, DO_ASSERT, atCall + 'IS_NULL is null');

Assert.warn('TEST_isUndefined: TESTS with IS_UNDEFINED');
Assert.isUndefined(IS_UNDEFINED, DO_ASSERT, atCall + 'IS_UNDEFINED is undefined');

Assert.warn('TEST_isUndefined: TESTS with IS_TRUE');
Assert.isUndefined(IS_TRUE, DO_ASSERT, atCall + 'IS_TRUE is true');

Assert.warn('TEST_isUndefined: TESTS with IS_FALSE');
Assert.isUndefined(IS_FALSE, DO_ASSERT, atCall + 'IS_FALSE is false');

Assert.warn('TEST_isUndefined: TESTS with IS_EMPTY_STRING');
Assert.isUndefined(IS_EMPTY_STRING, DO_ASSERT, atCall + 'IS_EMPTY_STRING is ""');

Assert.warn('TEST_isUndefined: TESTS with IS_STRING');
Assert.isUndefined(IS_STRING, DO_ASSERT, atCall + 'IS_STRING is ' + IS_STRING);

Assert.warn('TEST_isUndefined: TESTS with IS_ZERO_NUMBER');
Assert.isUndefined(IS_ZERO_NUMBER, DO_ASSERT, atCall + 'IS_ZERO_NUMBER is ' + IS_ZERO_NUMBER);

Assert.warn('TEST_isUndefined: TESTS with IS_NUMBER');
Assert.isUndefined(IS_NUMBER, DO_ASSERT, atCall + 'IS_NUMBER is ' + IS_NUMBER);

Assert.warn('TEST_isUndefined: TESTS with IS_HEX_NUMBER');
Assert.isUndefined(IS_HEX_NUMBER, DO_ASSERT, atCall + 'IS_HEX_NUMBER is ' + IS_HEX_NUMBER);

Assert.warn('TEST_isUndefined: TESTS with IS_EMPTY_ARRAY');
Assert.isUndefined(IS_EMPTY_ARRAY, DO_ASSERT, atCall + 'IS_EMPTY_ARRAY is []');

Assert.warn('TEST_isUndefined: TESTS with IS_ARRAY');
Assert.isUndefined(IS_ARRAY, DO_ASSERT, atCall + 'IS_ARRAY is [<\'jsAssertUnit\'>: "JAVASCRIPT" ASSERTION UNIT, 9876]');

Assert.warn('TEST_isUndefined: TESTS with IS_EMPTY_OBJECT');
Assert.isUndefined(IS_EMPTY_OBJECT, DO_ASSERT, atCall + 'IS_EMPTY_OBJECT is {}');

Assert.warn('TEST_isUndefined: TESTS with IS_OBJECT');
Assert.isUndefined(IS_OBJECT, DO_ASSERT, atCall + 'IS_OBJECT is {proString:<\'jsAssertUnit\'>: "JAVASCRIPT" ASSERTION UNIT, proInt:9876}');

/*
-------------------------
Assert.warn('TEST_isUndefined: TESTS with IS_FUNCTION');
Assert.isUndefined(IS_FUNCTION, DO_ASSERT, atCall + '"IS_FUNCTION" is function(){}');
-------------------------
*/
}	//---TEST_isUndefined

/*f)void*/function
TEST_isNotUndefined(){
var
/*string*/atCall = 'TEST_isNotUndefined: ';

Assert.warn('TEST_isNotUndefined: TESTS with IS_NULL');
Assert.isNotUndefined(IS_NULL, DO_ASSERT, atCall + 'IS_NULL is null');

Assert.warn('TEST_isNotUndefined: TESTS with IS_UNDEFINED');
Assert.isNotUndefined(IS_UNDEFINED, DO_ASSERT, atCall + 'IS_UNDEFINED is undefined');

Assert.warn('TEST_isNotUndefined: TESTS with IS_TRUE');
Assert.isNotUndefined(IS_TRUE, DO_ASSERT, atCall + 'IS_TRUE is true');

Assert.warn('TEST_isNotUndefined: TESTS with IS_FALSE');
Assert.isNotUndefined(IS_FALSE, DO_ASSERT, atCall + 'IS_FALSE is false');

Assert.warn('TEST_isNotUndefined: TESTS with IS_EMPTY_STRING');
Assert.isNotUndefined(IS_EMPTY_STRING, DO_ASSERT, atCall + 'IS_EMPTY_STRING is ""');

Assert.warn('TEST_isNotUndefined: TESTS with IS_STRING');
Assert.isNotUndefined(IS_STRING, DO_ASSERT, atCall + 'IS_STRING is ' + IS_STRING);

Assert.warn('TEST_isNotUndefined: TESTS with IS_ZERO_NUMBER');
Assert.isNotUndefined(IS_ZERO_NUMBER, DO_ASSERT, atCall + 'IS_ZERO_NUMBER is ' + IS_ZERO_NUMBER);

Assert.warn('TEST_isNotUndefined: TESTS with IS_NUMBER');
Assert.isNotUndefined(IS_NUMBER, DO_ASSERT, atCall + 'IS_NUMBER is ' + IS_NUMBER);

Assert.warn('TEST_isNotUndefined: TESTS with IS_HEX_NUMBER');
Assert.isNotUndefined(IS_HEX_NUMBER, DO_ASSERT, atCall + 'IS_HEX_NUMBER is ' + IS_HEX_NUMBER);

Assert.warn('TEST_isNotUndefined: TESTS with IS_EMPTY_ARRAY');
Assert.isNotUndefined(IS_EMPTY_ARRAY, DO_ASSERT, atCall + 'IS_EMPTY_ARRAY is []');

Assert.warn('TEST_isNotUndefined: TESTS with IS_ARRAY');
Assert.isNotUndefined(IS_ARRAY, DO_ASSERT, atCall + 'IS_ARRAY is [<\'jsAssertUnit\'>: "JAVASCRIPT" ASSERTION UNIT, 9876]');

Assert.warn('TEST_isNotUndefined: TESTS with IS_EMPTY_OBJECT');
Assert.isNotUndefined(IS_EMPTY_OBJECT, DO_ASSERT, atCall + 'IS_EMPTY_OBJECT is {}');

Assert.warn('TEST_isNotUndefined: TESTS with IS_OBJECT');
Assert.isNotUndefined(IS_OBJECT, DO_ASSERT, atCall + 'IS_OBJECT is {proString:<\'jsAssertUnit\'>: "JAVASCRIPT" ASSERTION UNIT, proInt:9876}');

/*
-------------------------
Assert.warn('TEST_isNotUndefined: TESTS with IS_FUNCTION');
Assert.isNotUndefined(IS_FUNCTION, DO_ASSERT, atCall + '"IS_FUNCTION" is function(){}');
-------------------------
*/
}	//---TEST_isNotUndefined

/*f)void*/function
TEST_isTrue(){
var
/*string*/atCall = 'TEST_isTrue: ';

Assert.warn('TEST_isTrue: TESTS with IS_NULL');
Assert.isTrue(IS_NULL, DO_ASSERT, atCall + 'IS_NULL is null');

Assert.warn('TEST_isTrue: TESTS with IS_UNDEFINED');
Assert.isTrue(IS_UNDEFINED, DO_ASSERT, atCall + 'IS_UNDEFINED is undefined');

Assert.warn('TEST_isTrue: TESTS with IS_TRUE');
Assert.isTrue(IS_TRUE, DO_ASSERT, atCall + 'IS_TRUE is true');

Assert.warn('TEST_isTrue: TESTS with IS_FALSE');
Assert.isTrue(IS_FALSE, DO_ASSERT, atCall + 'IS_FALSE is false');

Assert.warn('TEST_isTrue: TESTS with IS_EMPTY_STRING');
Assert.isTrue(IS_EMPTY_STRING, DO_ASSERT, atCall + 'IS_EMPTY_STRING is ""');

Assert.warn('TEST_isTrue: TESTS with IS_STRING');
Assert.isTrue(IS_STRING, DO_ASSERT, atCall + 'IS_STRING is ' + IS_STRING);

Assert.warn('TEST_isTrue: TESTS with IS_ZERO_NUMBER');
Assert.isTrue(IS_ZERO_NUMBER, DO_ASSERT, atCall + 'IS_ZERO_NUMBER is ' + IS_ZERO_NUMBER);

Assert.warn('TEST_isTrue: TESTS with IS_NUMBER');
Assert.isTrue(IS_NUMBER, DO_ASSERT, atCall + 'IS_NUMBER is ' + IS_NUMBER);

Assert.warn('TEST_isTrue: TESTS with IS_HEX_NUMBER');
Assert.isTrue(IS_HEX_NUMBER, DO_ASSERT, atCall + 'IS_HEX_NUMBER is ' + IS_HEX_NUMBER);

Assert.warn('TEST_isTrue: TESTS with IS_EMPTY_ARRAY');
Assert.isTrue(IS_EMPTY_ARRAY, DO_ASSERT, atCall + 'IS_EMPTY_ARRAY is []');

Assert.warn('TEST_isTrue: TESTS with IS_ARRAY');
Assert.isTrue(IS_ARRAY, DO_ASSERT, atCall + 'IS_ARRAY is [<\'jsAssertUnit\'>: "JAVASCRIPT" ASSERTION UNIT, 9876]');

Assert.warn('TEST_isTrue: TESTS with IS_EMPTY_OBJECT');
Assert.isTrue(IS_EMPTY_OBJECT, DO_ASSERT, atCall + 'IS_EMPTY_OBJECT is {}');

Assert.warn('TEST_isTrue: TESTS with IS_OBJECT');
Assert.isTrue(IS_OBJECT, DO_ASSERT, atCall + 'IS_OBJECT is {proString:<\'jsAssertUnit\'>: "JAVASCRIPT" ASSERTION UNIT, proInt:9876}');

/*
-------------------------
Assert.warn('TEST_isTrue: TESTS with IS_FUNCTION');
Assert.isTrue(IS_FUNCTION, DO_ASSERT, atCall + '"IS_FUNCTION" is function(){}');
-------------------------
*/
}	//---TEST_isTrue

/*f)void*/function
TEST_isFalse(){
var
/*string*/atCall = 'TEST_isFalse: ';

Assert.warn('TEST_isFalse: TESTS with IS_NULL');
Assert.isFalse(IS_NULL, DO_ASSERT, atCall + 'IS_NULL is null');

Assert.warn('TEST_isFalse: TESTS with IS_UNDEFINED');
Assert.isFalse(IS_UNDEFINED, DO_ASSERT, atCall + 'IS_UNDEFINED is undefined');

Assert.warn('TEST_isFalse: TESTS with IS_TRUE');
Assert.isFalse(IS_TRUE, DO_ASSERT, atCall + 'IS_TRUE is true');

Assert.warn('TEST_isFalse: TESTS with IS_FALSE');
Assert.isFalse(IS_FALSE, DO_ASSERT, atCall + 'IS_FALSE is false');

Assert.warn('TEST_isFalse: TESTS with IS_EMPTY_STRING');
Assert.isFalse(IS_EMPTY_STRING, DO_ASSERT, atCall + 'IS_EMPTY_STRING is ""');

Assert.warn('TEST_isFalse: TESTS with IS_STRING');
Assert.isFalse(IS_STRING, DO_ASSERT, atCall + 'IS_STRING is ' + IS_STRING);

Assert.warn('TEST_isFalse: TESTS with IS_ZERO_NUMBER');
Assert.isFalse(IS_ZERO_NUMBER, DO_ASSERT, atCall + 'IS_ZERO_NUMBER is ' + IS_ZERO_NUMBER);

Assert.warn('TEST_isFalse: TESTS with IS_NUMBER');
Assert.isFalse(IS_NUMBER, DO_ASSERT, atCall + 'IS_NUMBER is ' + IS_NUMBER);

Assert.warn('TEST_isFalse: TESTS with IS_HEX_NUMBER');
Assert.isFalse(IS_HEX_NUMBER, DO_ASSERT, atCall + 'IS_HEX_NUMBER is ' + IS_HEX_NUMBER);

Assert.warn('TEST_isFalse: TESTS with IS_EMPTY_ARRAY');
Assert.isFalse(IS_EMPTY_ARRAY, DO_ASSERT, atCall + 'IS_EMPTY_ARRAY is []');

Assert.warn('TEST_isFalse: TESTS with IS_ARRAY');
Assert.isFalse(IS_ARRAY, DO_ASSERT, atCall + 'IS_ARRAY is [<\'jsAssertUnit\'>: "JAVASCRIPT" ASSERTION UNIT, 9876]');

Assert.warn('TEST_isFalse: TESTS with IS_EMPTY_OBJECT');
Assert.isFalse(IS_EMPTY_OBJECT, DO_ASSERT, atCall + 'IS_EMPTY_OBJECT is {}');

Assert.warn('TEST_isFalse: TESTS with IS_OBJECT');
Assert.isFalse(IS_OBJECT, DO_ASSERT, atCall + 'IS_OBJECT is {proString:<\'jsAssertUnit\'>: "JAVASCRIPT" ASSERTION UNIT, proInt:9876}');

/*
-------------------------
Assert.warn('TEST_isFalse: TESTS with IS_FUNCTION');
Assert.isFalse(IS_FUNCTION, DO_ASSERT, atCall + '"IS_FUNCTION" is function(){}');
-------------------------
*/
}	//---TEST_isFalse

/*f)void*/function
TEST_isNumber(){
var
/*string*/atCall = 'TEST_isNumber: ';

Assert.warn('TEST_isNumber: TESTS with IS_NULL');
Assert.isNumber(IS_NULL, DO_ASSERT, atCall + 'IS_NULL is null');

Assert.warn('TEST_isNumber: TESTS with IS_UNDEFINED');
Assert.isNumber(IS_UNDEFINED, DO_ASSERT, atCall + 'IS_UNDEFINED is undefined');

Assert.warn('TEST_isNumber: TESTS with IS_TRUE');
Assert.isNumber(IS_TRUE, DO_ASSERT, atCall + 'IS_TRUE is true');

Assert.warn('TEST_isNumber: TESTS with IS_FALSE');
Assert.isNumber(IS_FALSE, DO_ASSERT, atCall + 'IS_FALSE is false');

Assert.warn('TEST_isNumber: TESTS with IS_EMPTY_STRING');
Assert.isNumber(IS_EMPTY_STRING, DO_ASSERT, atCall + 'IS_EMPTY_STRING is ""');

Assert.warn('TEST_isNumber: TESTS with IS_STRING');
Assert.isNumber(IS_STRING, DO_ASSERT, atCall + 'IS_STRING is ' + IS_STRING);

Assert.warn('TEST_isNumber: TESTS with IS_ZERO_NUMBER');
Assert.isNumber(IS_ZERO_NUMBER, DO_ASSERT, atCall + 'IS_ZERO_NUMBER is ' + IS_ZERO_NUMBER);

Assert.warn('TEST_isNumber: TESTS with IS_NUMBER');
Assert.isNumber(IS_NUMBER, DO_ASSERT, atCall + 'IS_NUMBER is ' + IS_NUMBER);

Assert.warn('TEST_isNumber: TESTS with IS_HEX_NUMBER');
Assert.isNumber(IS_HEX_NUMBER, DO_ASSERT, atCall + 'IS_HEX_NUMBER is ' + IS_HEX_NUMBER);

Assert.warn('TEST_isNumber: TESTS with IS_EMPTY_ARRAY');
Assert.isNumber(IS_EMPTY_ARRAY, DO_ASSERT, atCall + 'IS_EMPTY_ARRAY is []');

Assert.warn('TEST_isNumber: TESTS with IS_ARRAY');
Assert.isNumber(IS_ARRAY, DO_ASSERT, atCall + 'IS_ARRAY is [<\'jsAssertUnit\'>: "JAVASCRIPT" ASSERTION UNIT, 9876]');

Assert.warn('TEST_isNumber: TESTS with IS_EMPTY_OBJECT');
Assert.isNumber(IS_EMPTY_OBJECT, DO_ASSERT, atCall + 'IS_EMPTY_OBJECT is {}');

Assert.warn('TEST_isNumber: TESTS with IS_OBJECT');
Assert.isNumber(IS_OBJECT, DO_ASSERT, atCall + 'IS_OBJECT is {proString:<\'jsAssertUnit\'>: "JAVASCRIPT" ASSERTION UNIT, proInt:9876}');

/*
-------------------------
Assert.warn('TEST_isNumber: TESTS with IS_FUNCTION');
Assert.isNumber(IS_FUNCTION, DO_ASSERT, atCall + '"IS_FUNCTION" is function(){}');
-------------------------
*/
}	//---TEST_isNumber

/*f)void*/function
TEST_isNotNumber(){
var
/*string*/atCall = 'TEST_isNotNumber: ';

Assert.warn('TEST_isNotNumber: TESTS with IS_NULL');
Assert.isNotNumber(IS_NULL, DO_ASSERT, atCall + 'IS_NULL is null');

Assert.warn('TEST_isNotNumber: TESTS with IS_UNDEFINED');
Assert.isNotNumber(IS_UNDEFINED, DO_ASSERT, atCall + 'IS_UNDEFINED is undefined');

Assert.warn('TEST_isNotNumber: TESTS with IS_TRUE');
Assert.isNotNumber(IS_TRUE, DO_ASSERT, atCall + 'IS_TRUE is true');

Assert.warn('TEST_isNotNumber: TESTS with IS_FALSE');
Assert.isNotNumber(IS_FALSE, DO_ASSERT, atCall + 'IS_FALSE is false');

Assert.warn('TEST_isNotNumber: TESTS with IS_EMPTY_STRING');
Assert.isNotNumber(IS_EMPTY_STRING, DO_ASSERT, atCall + 'IS_EMPTY_STRING is ""');

Assert.warn('TEST_isNotNumber: TESTS with IS_STRING');
Assert.isNotNumber(IS_STRING, DO_ASSERT, atCall + 'IS_STRING is ' + IS_STRING);

Assert.warn('TEST_isNotNumber: TESTS with IS_ZERO_NUMBER');
Assert.isNotNumber(IS_ZERO_NUMBER, DO_ASSERT, atCall + 'IS_ZERO_NUMBER is ' + IS_ZERO_NUMBER);

Assert.warn('TEST_isNotNumber: TESTS with IS_NUMBER');
Assert.isNotNumber(IS_NUMBER, DO_ASSERT, atCall + 'IS_NUMBER is ' + IS_NUMBER);

Assert.warn('TEST_isNotNumber: TESTS with IS_HEX_NUMBER');
Assert.isNotNumber(IS_HEX_NUMBER, DO_ASSERT, atCall + 'IS_HEX_NUMBER is ' + IS_HEX_NUMBER);

Assert.warn('TEST_isNotNumber: TESTS with IS_EMPTY_ARRAY');
Assert.isNotNumber(IS_EMPTY_ARRAY, DO_ASSERT, atCall + 'IS_EMPTY_ARRAY is []');

Assert.warn('TEST_isNotNumber: TESTS with IS_ARRAY');
Assert.isNotNumber(IS_ARRAY, DO_ASSERT, atCall + 'IS_ARRAY is [<\'jsAssertUnit\'>: "JAVASCRIPT" ASSERTION UNIT, 9876]');

Assert.warn('TEST_isNotNumber: TESTS with IS_EMPTY_OBJECT');
Assert.isNotNumber(IS_EMPTY_OBJECT, DO_ASSERT, atCall + 'IS_EMPTY_OBJECT is {}');

Assert.warn('TEST_isNotNumber: TESTS with IS_OBJECT');
Assert.isNotNumber(IS_OBJECT, DO_ASSERT, atCall + 'IS_OBJECT is {proString:<\'jsAssertUnit\'>: "JAVASCRIPT" ASSERTION UNIT, proInt:9876}');

/*
-------------------------
Assert.warn('TEST_isNotNumber: TESTS with IS_FUNCTION');
Assert.isNotNumber(IS_FUNCTION, DO_ASSERT, atCall + '"IS_FUNCTION" is function(){}');
-------------------------
*/
}	//---TEST_isNotNumber

/*f)void*/function
TEST_isEqualToString(){
var
/*string*/atCall = 'TEST_isEqualToString: ';

Assert.warn('TEST_isEqualToString: TESTS with IS_NULL');
Assert.isEqual(IS_STRING, IS_NULL, DO_ASSERT, atCall + 'IS_NULL is null');

Assert.warn('TEST_isEqualToString: TESTS with IS_UNDEFINED');
Assert.isEqual(IS_STRING, IS_UNDEFINED, DO_ASSERT, atCall + 'IS_UNDEFINED is undefined');

Assert.warn('TEST_isEqualToString: TESTS with IS_TRUE');
Assert.isEqual(IS_STRING, IS_TRUE, DO_ASSERT, atCall + 'IS_TRUE is true');

Assert.warn('TEST_isEqualToString: TESTS with IS_FALSE');
Assert.isEqual(IS_STRING, IS_FALSE, DO_ASSERT, atCall + 'IS_FALSE is false');

Assert.warn('TEST_isEqualToString: TESTS with IS_EMPTY_STRING');
Assert.isEqual(IS_STRING, IS_EMPTY_STRING, DO_ASSERT, atCall + 'IS_EMPTY_STRING is ""');

Assert.warn('TEST_isEqualToString: TESTS with IS_STRING');
Assert.isEqual(IS_STRING, IS_STRING, DO_ASSERT, atCall + 'IS_STRING is ' + IS_STRING);

Assert.warn('TEST_isEqualToString: TESTS with IS_ZERO_NUMBER');
Assert.isEqual(IS_STRING, IS_ZERO_NUMBER, DO_ASSERT, atCall + 'IS_ZERO_NUMBER is ' + IS_ZERO_NUMBER);

Assert.warn('TEST_isEqualToString: TESTS with IS_ZERO_NUMBER');
Assert.isEqual(IS_STRING, IS_NUMBER, DO_ASSERT, atCall + 'IS_NUMBER is ' + IS_NUMBER);

Assert.warn('TEST_isEqualToString: TESTS with IS_HEX_NUMBER');
Assert.isEqual(IS_STRING, IS_HEX_NUMBER, DO_ASSERT, atCall + 'IS_HEX_NUMBER is ' + IS_HEX_NUMBER);

Assert.warn('TEST_isEqualToString: TESTS with IS_EMPTY_ARRAY');
Assert.isEqual(IS_STRING, IS_EMPTY_ARRAY, DO_ASSERT, atCall + 'IS_EMPTY_ARRAY is []');

Assert.warn('TEST_isEqualToString: TESTS with IS_ARRAY');
Assert.isEqual(IS_STRING, IS_ARRAY, DO_ASSERT, atCall + 'IS_ARRAY is [<\'jsAssertUnit\'>: "JAVASCRIPT" ASSERTION UNIT, 9876]');

Assert.warn('TEST_isEqualToString: TESTS with IS_EMPTY_OBJECT');
Assert.isEqual(IS_STRING, IS_EMPTY_OBJECT, DO_ASSERT, atCall + 'IS_EMPTY_OBJECT is {}');

Assert.warn('TEST_isEqualToString: TESTS with IS_OBJECT');
Assert.isEqual(IS_STRING, IS_OBJECT, DO_ASSERT, atCall + 'IS_OBJECT is {proString:<\'jsAssertUnit\'>: "JAVASCRIPT" ASSERTION UNIT, proInt:9876}');

/*
-------------------------
Assert.warn('TEST_isEqualToString: TESTS with IS_FUNCTION');
Assert.isEqual(IS_STRING, IS_FUNCTION, DO_ASSERT, atCall + '"IS_FUNCTION" is function(){}');
-------------------------
*/
}	//---TEST_isEqualToStringToString

/*f)void*/function
TEST_isNotEqualToString(){
var
/*string*/atCall = 'TEST_isNotEqualToString: ';

Assert.warn('TEST_isNotEqualToString: TESTS with IS_NULL');
Assert.isNotEqual(IS_STRING, IS_NULL, DO_ASSERT, atCall + 'IS_NULL is null');

Assert.warn('TEST_isNotEqualToString: TESTS with IS_UNDEFINED');
Assert.isNotEqual(IS_STRING, IS_UNDEFINED, DO_ASSERT, atCall + 'IS_UNDEFINED is undefined');

Assert.warn('TEST_isNotEqualToString: TESTS with IS_TRUE');
Assert.isNotEqual(IS_STRING, IS_TRUE, DO_ASSERT, atCall + 'IS_TRUE is true');

Assert.warn('TEST_isNotEqualToString: TESTS with IS_FALSE');
Assert.isNotEqual(IS_STRING, IS_FALSE, DO_ASSERT, atCall + 'IS_FALSE is false');

Assert.warn('TEST_isNotEqualToString: TESTS with IS_EMPTY_STRING');
Assert.isNotEqual(IS_STRING, IS_EMPTY_STRING, DO_ASSERT, atCall + 'IS_EMPTY_STRING is ""');

Assert.warn('TEST_isNotEqualToString: TESTS with IS_STRING');
Assert.isNotEqual(IS_STRING, IS_STRING, DO_ASSERT, atCall + 'IS_STRING is ' + IS_STRING);

Assert.warn('TEST_isNotEqualToString: TESTS with IS_ZERO_NUMBER');
Assert.isNotEqual(IS_STRING, IS_ZERO_NUMBER, DO_ASSERT, atCall + 'IS_ZERO_NUMBER is ' + IS_ZERO_NUMBER);

Assert.warn('TEST_isNotEqualToString: TESTS with IS_NUMBER');
Assert.isNotEqual(IS_STRING, IS_NUMBER, DO_ASSERT, atCall + 'IS_NUMBER is ' + IS_NUMBER);

Assert.warn('TEST_isNotEqualToString: TESTS with IS_HEX_NUMBER');
Assert.isNotEqual(IS_STRING, IS_HEX_NUMBER, DO_ASSERT, atCall + 'IS_HEX_NUMBER is ' + IS_HEX_NUMBER);

Assert.warn('TEST_isNotEqualToString: TESTS with IS_EMPTY_ARRAY');
Assert.isNotEqual(IS_STRING, IS_EMPTY_ARRAY, DO_ASSERT, atCall + 'IS_EMPTY_ARRAY is []');

Assert.warn('TEST_isNotEqualToString: TESTS with IS_ARRAY');
Assert.isNotEqual(IS_STRING, IS_ARRAY, DO_ASSERT, atCall + 'IS_ARRAY is [<\'jsAssertUnit\'>: "JAVASCRIPT" ASSERTION UNIT, 9876]');

Assert.warn('TEST_isNotEqualToString: TESTS with IS_EMPTY_OBJECT');
Assert.isNotEqual(IS_STRING, IS_EMPTY_OBJECT, DO_ASSERT, atCall + 'IS_EMPTY_OBJECT is {}');

Assert.warn('TEST_isNotEqualToString: TESTS with IS_OBJECT');
Assert.isNotEqual(IS_STRING, IS_OBJECT, DO_ASSERT, atCall + 'IS_OBJECT is {proString:<\'jsAssertUnit\'>: "JAVASCRIPT" ASSERTION UNIT, proInt:9876}');

/*
-------------------------
Assert.warn('TEST_isNotEqualToString: TESTS with IS_FUNCTION');
Assert.isNotEqual(IS_STRING, IS_FUNCTION, DO_ASSERT, atCall + '"IS_FUNCTION" is function(){}');
-------------------------
*/
}	//---TEST_isNotEqualToString

